#ifndef SKELETON_H_
#define SKELETON_H_

#include "tinymt32.h"

#define BUFFER_LEN 10000

// INIT-Functions.
void EDMA_init(void);
void INTERRUPTS_init(void);
void AIC23_init(void);
void AIC23_setRegister(MCBSP_Handle hMcbsp, unsigned short regnum, unsigned short regval);

// Service-Routines.
void EDMA_interrupt_service(void);
void process_ping_SWI(void);
void process_pong_SWI(void);

// System-Identification-Functions.
void generateWhiteNoise(short ping_pong_selector);
void calculateCrossCorrelation(float *resultVector, short *noiseVector, short *receiveVector);
void estimateImpulseResponse(void);
void estimatePropagationDelay(void);
void estimateFrequencyResponse(void);

// verschiedene Handles //
MCBSP_Handle hMcbsp0;						// Handle auf McBSP0 - Steuerkanal
MCBSP_Handle hMcbsp1;						// Handle auf McBSP1 - Datenkanal
EDMA_Handle hEdmaRcv; 						// Handle auf EDMA REVT1-Channel
EDMA_Handle hEdmaXmt;						// Handle auf EDMA XEVT1-Channel
EDMA_Handle hEdmaReload_Buffer_IN_Ping;		// Handle auf einen reload-Parametersatz
EDMA_Handle hEdmaReload_Buffer_IN_Pong;		// Handle auf einen reload-Parametersatz
EDMA_Handle hEdmaReload_Buffer_OUT_Ping;	// Handle auf einen reload-Parametersatz
EDMA_Handle hEdmaReload_Buffer_OUT_Pong;	// Handle auf einen reload-Parametersatz

// Puffer im L2-Cache (Buffer_XX_Xxxx-Variablen sind Pointer auf das erste Element des entsprechenden Arrays!) //
#pragma DATA_SECTION(Buffer_IN_Ping, ".datenpuffer");
short Buffer_IN_Ping[BUFFER_LEN];
#pragma DATA_SECTION(Buffer_IN_Pong, ".datenpuffer");
short Buffer_IN_Pong[BUFFER_LEN];
#pragma DATA_SECTION(Buffer_OUT_Ping, ".datenpuffer");
short Buffer_OUT_Ping[BUFFER_LEN];
#pragma DATA_SECTION(Buffer_OUT_Pong, ".datenpuffer");
short Buffer_OUT_Pong[BUFFER_LEN];

// Datenpuffer für Impulsantwort (10x1024 Werte)
// d.h. alle 10 Impulsantwortkalkulationen stehen in einem Array!
#pragma DATA_SECTION(Buffer_Impulse_Responses, ".datenpuffer");
float Buffer_Impulse_Responses[20480];

// Berechnete Impulsantwort
#pragma DATA_SECTION(estimated_Impulse_Response, ".datenpuffer");
float estimated_Impulse_Response[1024];

// Datenpuffer für FFT
#pragma DATA_SECTION(estimated_FFT, ".datenpuffer");
float estimated_FFT[2048];
#pragma DATA_SECTION(twiddle_factor_array, ".datenpuffer");
float twiddle_factor_array[768];

// Transfer-Complete-Codes der EDMA-Jobs //
int tccRcvPing = 0;
int tccRcvPong = 0;
int tccXmtPing = 0;
int tccXmtPong = 0;

// Statusvariablen, die den Schreib- und Lesestatus der Ping-/Pong-Buffer anzeigen.
int rcvPingDone = 0;
int rcvPongDone = 0;
int xmtPingDone = 0;
int xmtPongDone = 0;

// First-call-status of Ping/Pong-Interrupt-Routines
int firstCallPing = 1;
int firstCallPong = 1;

// Generate White Noise variables + Tiny Mersenne Twister.
tinymt32_t state;
uint32_t seed;
int writeToBuffer = 0;

// Impulsantwort-Berechnung
int calculateImpulseResponseCycle = 0;	// Nummer des aktuellen Berechnungsdurchgang der Impulsantwort.
float estimatedPropagationDelay = 0.0f;	// Berechnete Übertragungszeit.



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																															//
//															EDMA_CONFIGS													//
//																															//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////
// Buffer_IN_Ping //
////////////////////

EDMA_Config configEDMA_Buffer_IN_Ping =
{
    EDMA_FMKS(OPT, PRI, HIGH)          |  // Auf beide Queues verteilen 	(Buffer_IN_Ping auf HIGH | Buffer_OUT_Ping auf LOW
    									  //								 Buffer_IN_Pong auf HIGH | Buffer_OUT_Pong auf LOW)
    EDMA_FMKS(OPT, ESIZE, 16BIT)       |  // Element size					(32Bit Worte über McBSP1)
    EDMA_FMKS(OPT, 2DS, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, SUM, NONE)          |  // Quell-update mode				(FESTE QUELLE von McBSP1-Data Receive Register (DRR))
    EDMA_FMKS(OPT, 2DD, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, DUM, INC)           |  // Ziel-update mode				(Jedes neue Wort wird an das letzte, übertragene Wort angehängt)
    EDMA_FMKS(OPT, TCINT, YES)         |  // EDMA interrupt erzeugen?		(JA, damit die CPU Bescheid weiß, dass ein neuer Datensatz
    									  //								 von 10.000 Elementen in den Ping-Buffer geschrieben wurde
    									  //								 und zur weiteren Verarbeitung bereit liegt)
    EDMA_FMKS(OPT, TCC, OF(0))         |  // Transfer complete code (TCC)	(Beispielkonfiguration:
    									  //								 0 = Buffer_IN_Ping | 2 = Buffer_OUT_Ping
    									  //								 1 = Buffer_IN_Pong | 3 = Buffer_OUT_Pong
    									  //								 Es wird EDMA_intAlloc(-1) im c-Programm verwendet um die TCCs
    									  //								 automatisch zuzuweisen!)
    EDMA_FMKS(OPT, LINK, YES)          |  // Link Parameter nutzen?			(JA, denn nach erfolgreichem Abspeichern von 10.000 Werten soll
    									  //								 zum Pong-Buffer gesprungen werden und die nächsten 10.000
    									  //								 Werte aufgenommen werden.)
    EDMA_FMKS(OPT, FS, NO),               // Frame Sync nutzen?				(NEIN, es werden nacheinander einzelne 32Bit-Worte vom McBSP in
    									  //								 den Ping-Buffer geschrieben = element-synchronized!)

    EDMA_FMKS(SRC, SRC, OF(0)),   		  // Quell-Adresse					(McBSP1-DRR-Adresse wird im c-Programm per MCBSP_getRcvAddr(hMcbsp)
    									  //								 geholt und per configEDMA_Buffer_IN_Ping.src gesetzt.)

    EDMA_FMK (CNT, FRMCNT, NULL)       |  // Anzahl Frames					(Es wird ein einziges Frame übertragen)
    EDMA_FMK (CNT, ELECNT, BUFFER_LEN),   // Anzahl Elemente				(10.000 Elemente werden innerhalb dieses Frames übertragen)

    (Uint32)Buffer_IN_Ping,       		  // Ziel-Adresse					(Zieladresse im L2-Cache, siehe Puffer-Definitionen weiter oben)

    EDMA_FMKS(IDX, FRMIDX, DEFAULT)    |  // Frame index Wert				(Kein Offset zwischen Frames einstellen | DEFAULT = 0)
    EDMA_FMKS(IDX, ELEIDX, DEFAULT),      // Element index Wert				(Kein Offset zwischen Elementen einstellen | DEFAULT = 0)

    EDMA_FMK (RLD, ELERLD, NULL) 	   |  // Reload Element					(Nach erfolgreichem Schreiben von 10.000 Elementen in den
    									  //								 Ping-Buffer wird der ELECNT wieder auf 10.000 zurückgesetzt
    									  //								 damit beim nächsten Schreibvorgang wieder 10.000 Elemente
    									  //								 in den Ping-Buffer geschrieben werden.
    									  //								 Muss ansonsten nur bei Multiframe-Transfers gesetzt werden, damit ELECNT
    									  //								 für jedes weitere Frame von neuem geladen werden kann.)
    EDMA_FMK (RLD, LINK, 0)               // Reload Link					(01A0 xxxxh ist die Adresse für das jeweilige Reloadset im PaRAM:
    									  //								 0180h (384d) - Buffer_IN_Ping
    									  //								 0198h (408d) - Buffer_IN_Pong
    									  //								 01B0h (432d) - Buffer_OUT_Ping
    									  //								 01C8h (456d) - Buffer_OUT_Pong
    									  //								 Die Verlinkung von PaRAM-Sets findet über die csl-function
    									  //								 EDMA_link() im c-Programm::config_EDMA() statt.)
};

////////////////////
// Buffer_IN_Pong //
////////////////////

EDMA_Config configEDMA_Buffer_IN_Pong =
{
    EDMA_FMKS(OPT, PRI, HIGH)          |  // Auf beide Queues verteilen 	(Buffer_IN_Ping auf HIGH | Buffer_OUT_Ping auf LOW
    									  //								 Buffer_IN_Pong auf HIGH | Buffer_OUT_Pong auf LOW)
    EDMA_FMKS(OPT, ESIZE, 16BIT)       |  // Element size					(32Bit Worte über McBSP1)
    EDMA_FMKS(OPT, 2DS, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, SUM, NONE)          |  // Quell-update mode				(FESTE QUELLE von McBSP1-Data Receive Register (DRR))
    EDMA_FMKS(OPT, 2DD, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, DUM, INC)           |  // Ziel-update mode				(Jedes neue Wort wird an das letzte, übertragene Wort angehängt)
    EDMA_FMKS(OPT, TCINT, YES)         |  // EDMA interrupt erzeugen?		(JA, damit die CPU Bescheid weiß, dass ein neuer Datensatz
    									  //								 von 10.000 Elementen in den Pong-Buffer geschrieben wurde
    									  //								 und zur weiteren Verarbeitung bereit liegt)
    EDMA_FMKS(OPT, TCC, OF(0))         |  // Transfer complete code (TCC)	(Beispielkonfiguration:
										  //								 0 = Buffer_IN_Ping | 2 = Buffer_OUT_Ping
										  //								 1 = Buffer_IN_Pong | 3 = Buffer_OUT_Pong
										  //								 Es wird EDMA_intAlloc(-1) im c-Programm verwendet um die TCCs
										  //								 automatisch zuzuweisen!)
    EDMA_FMKS(OPT, LINK, YES)          |  // Link Parameter nutzen?			(JA, denn nach erfolgreichem Abspeichern von 10.000 Werten soll
    									  //								 zum Ping-Buffer gesprungen werden und die nächsten 10.000
    									  //								 Werte aufgenommen werden.)
    EDMA_FMKS(OPT, FS, NO),               // Frame Sync nutzen?				(NEIN, es werden nacheinander einzelne 32Bit-Worte vom McBSP in
    									  //								 den Pong-Buffer geschrieben = element-synchronized!)

    EDMA_FMKS(SRC, SRC, OF(0)),  		  // Quell-Adresse					(McBSP1-DRR-Adresse wird im c-Programm per MCBSP_getRcvAddr(hMcbsp)
    									  //								 geholt und per configEDMA_Buffer_IN_Pong.src gesetzt.)

    EDMA_FMK (CNT, FRMCNT, NULL)       |  // Anzahl Frames					(Es wird ein einziges Frame übertragen)
    EDMA_FMK (CNT, ELECNT, BUFFER_LEN),   // Anzahl Elemente				(10.000 Elemente werden innerhalb dieses Frames übertragen)

    (Uint32)Buffer_IN_Pong,       		  // Ziel-Adresse					(Zieladresse im L2-Cache, siehe Puffer-Definitionen weiter oben)

    EDMA_FMKS(IDX, FRMIDX, DEFAULT)    |  // Frame index Wert				(Kein Offset zwischen Frames einstellen | DEFAULT = 0)
    EDMA_FMKS(IDX, ELEIDX, DEFAULT),      // Element index Wert				(Kein Offset zwischen Elementen einstellen | DEFAULT = 0)

    EDMA_FMK (RLD, ELERLD, NULL) 	   |  // Reload Element					(Nach erfolgreichem Schreiben von 10.000 Elementen in den
    									  //								 Pong-Buffer wird der ELECNT wieder auf 10.000 zurückgesetzt
    									  //								 damit beim nächsten Schreibvorgang wieder 10.000 Elemente
    									  //								 in den Pong-Buffer geschrieben werden.
    									  //								 Muss ansonsten nur bei Multiframe-Transfers gesetzt werden, damit ELECNT
    									  //								 für jedes weitere Frame von neuem geladen werden kann.)
    EDMA_FMK (RLD, LINK, 0)               // Reload Link					(01A0 xxxxh ist die Adresse für das jeweilige Reloadset im PaRAM:
    									  //								 0180h (384d) - Buffer_IN_Ping
    									  //								 0198h (408d) - Buffer_IN_Pong
    									  //								 01B0h (432d) - Buffer_OUT_Ping
    									  //								 01C8h (456d) - Buffer_OUT_Pong
    									  //								 Die Verlinkung von PaRAM-Sets findet über die csl-function
    									  //								 EDMA_link() im c-Programm::config_EDMA() statt.)
};

/////////////////////
// Buffer_OUT_Ping //
/////////////////////

EDMA_Config configEDMA_Buffer_OUT_Ping =
{
    EDMA_FMKS(OPT, PRI, LOW)           |  // Auf beide Queues verteilen 	(Buffer_IN_Ping auf HIGH | Buffer_OUT_Ping auf LOW
    									  //								 Buffer_IN_Pong auf HIGH | Buffer_OUT_Pong auf LOW)
    EDMA_FMKS(OPT, ESIZE, 16BIT)       |  // Element size					(32Bit Worte über McBSP1)
    EDMA_FMKS(OPT, 2DS, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, SUM, INC)           |  // Quell-update mode				(Es werden nacheinander, einzelne 32Bit Worte aus dem Buffer gelesen)
    EDMA_FMKS(OPT, 2DD, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, DUM, NONE)          |  // Ziel-update mode				(FESTES ZIEL: McBSP1-Data Transmit Register (DXR))
    EDMA_FMKS(OPT, TCINT, YES)         |  // EDMA interrupt erzeugen?		(JA, damit die CPU Bescheid weiß, dass 10.000 Elementen
    									  //								 übertragen wurden und nun die nächsten 10.000 Zufallszahlen
    									  //								 in den Ping-Buffer geschrieben werden können)
    EDMA_FMKS(OPT, TCC, OF(0))         |  // Transfer complete code (TCC)	(Beispielkonfiguration:
										  //								 0 = Buffer_IN_Ping | 2 = Buffer_OUT_Ping
										  //								 1 = Buffer_IN_Pong | 3 = Buffer_OUT_Pong
										  //								 Es wird EDMA_intAlloc(-1) im c-Programm verwendet um die TCCs
										  //								 automatisch zuzuweisen!)
    EDMA_FMKS(OPT, LINK, YES)          |  // Link Parameter nutzen?			(JA, denn nach erfolgreichem Übertragen von 10.000 Werten soll
    									  //								 zum Pong-Buffer gesprungen werden und die nächsten 10.000
    									  //								 Werte übertragen werden.)
    EDMA_FMKS(OPT, FS, NO),               // Frame Sync nutzen?				(NEIN, es werden nacheinander einzelne 32Bit-Worte vom Ping-Buffer in
    									  //								 den McBSP1 geschrieben = element-synchronized!)

    (Uint32)Buffer_OUT_Ping,         	  // Quell-Adresse					(Quelladresse im L2-Cache, siehe Puffer-Definitionen weiter oben)

    EDMA_FMK (CNT, FRMCNT, NULL)       |  // Anzahl Frames					(Es wird ein einziges Frame übertragen)
    EDMA_FMK (CNT, ELECNT, BUFFER_LEN),   // Anzahl Elemente				(10.000 Elemente werden innerhalb dieses Frames übertragen)

    EDMA_FMKS(SRC, SRC, OF(0)),       	  // Ziel-Adresse					(McBSP1-DXR-Adresse wird im c-Programm per MCBSP_getXmtAddr(hMcbsp)
    									  //								 geholt und per configEDMA_Buffer_OUT_Ping.src gesetzt.)

    EDMA_FMKS(IDX, FRMIDX, DEFAULT)    |  // Frame index Wert				(Kein Offset zwischen Frames einstellen | DEFAULT = 0)
    EDMA_FMKS(IDX, ELEIDX, DEFAULT),      // Element index Wert				(Kein Offset zwischen Elementen einstellen | DEFAULT = 0)

    EDMA_FMK (RLD, ELERLD, NULL) 	   |  // Reload Element					(Nach erfolgreichem Schreiben von 10.000 Elementen in den
    									  //								 McBSP wird der ELECNT wieder auf 10.000 zurückgesetzt
    									  //								 damit beim nächsten Schreibvorgang wieder 10.000 Elemente
    									  //								 in den McBSP geschrieben werden.
    									  //								 Muss ansonsten nur bei Multiframe-Transfers gesetzt werden, damit ELECNT
    									  //								 für jedes weitere Frame von neuem geladen werden kann.)
    EDMA_FMK (RLD, LINK, 0)               // Reload Link					(01A0 xxxxh ist die Adresse für das jeweilige Reloadset im PaRAM:
    									  //								 0180h (384d) - Buffer_IN_Ping
    									  //								 0198h (408d) - Buffer_IN_Pong
    									  //								 01B0h (432d) - Buffer_OUT_Ping
    									  //								 01C8h (456d) - Buffer_OUT_Pong
    									  //								 Die Verlinkung von PaRAM-Sets findet über die csl-function
    									  //								 EDMA_link() im c-Programm::config_EDMA() statt.)
};

/////////////////////
// Buffer_OUT_Pong //
/////////////////////

EDMA_Config configEDMA_Buffer_OUT_Pong =
{
    EDMA_FMKS(OPT, PRI, LOW)           |  // Auf beide Queues verteilen 	(Buffer_IN_Ping auf HIGH | Buffer_OUT_Ping auf LOW
    									  //								 Buffer_IN_Pong auf HIGH | Buffer_OUT_Pong auf LOW)
    EDMA_FMKS(OPT, ESIZE, 16BIT)       |  // Element size					(32Bit Worte über McBSP1)
    EDMA_FMKS(OPT, 2DS, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, SUM, INC)           |  // Quell-update mode				(Es werden nacheinander, einzelne 32Bit Worte aus dem Buffer gelesen)
    EDMA_FMKS(OPT, 2DD, NO)            |  // Kein 2D-Transfer
    EDMA_FMKS(OPT, DUM, NONE)          |  // Ziel-update mode				(FESTES ZIEL: McBSP1-Data Transmit Register (DXR))
    EDMA_FMKS(OPT, TCINT, YES)         |  // EDMA interrupt erzeugen?		(JA, damit die CPU Bescheid weiß, dass 10.000 Elementen
    									  //								 übertragen wurden und nun die nächsten 10.000 Zufallszahlen
    									  //								 in den Pong-Buffer geschrieben werden können)
    EDMA_FMKS(OPT, TCC, OF(0))         |  // Transfer complete code (TCC)	(Beispielkonfiguration:
										  //								 0 = Buffer_IN_Ping | 2 = Buffer_OUT_Ping
										  //								 1 = Buffer_IN_Pong | 3 = Buffer_OUT_Pong
										  //								 Es wird EDMA_intAlloc(-1) im c-Programm verwendet um die TCCs
										  //								 automatisch zuzuweisen!)
    EDMA_FMKS(OPT, LINK, YES)          |  // Link Parameter nutzen?			(JA, denn nach erfolgreichem Übertragen von 10.000 Werten soll
    									  //								 zum Ping-Buffer gesprungen werden und die nächsten 10.000
    									  //								 Werte übertragen werden.)
    EDMA_FMKS(OPT, FS, NO),               // Frame Sync nutzen?				(NEIN, es werden nacheinander einzelne 32Bit-Worte vom Pong-Buffer in
    									  //								 den McBSP1 geschrieben = element-synchronized!)

    (Uint32)Buffer_OUT_Pong,         	  // Quell-Adresse					(Quelladresse im L2-Cache, siehe Puffer-Definitionen weiter oben)

    EDMA_FMK (CNT, FRMCNT, NULL)       |  // Anzahl Frames					(Es wird ein einziges Frame übertragen)
    EDMA_FMK (CNT, ELECNT, BUFFER_LEN),   // Anzahl Elemente				(10.000 Elemente werden innerhalb dieses Frames übertragen)

    EDMA_FMKS(SRC, SRC, OF(0)),       	  // Ziel-Adresse					(McBSP1-DXR-Adresse wird im c-Programm per MCBSP_getXmtAddr(hMcbsp)
    									  //								 geholt und per configEDMA_Buffer_OUT_Pong.src gesetzt.)

    EDMA_FMKS(IDX, FRMIDX, DEFAULT)    |  // Frame index Wert				(Kein Offset zwischen Frames einstellen | DEFAULT = 0)
    EDMA_FMKS(IDX, ELEIDX, DEFAULT),      // Element index Wert				(Kein Offset zwischen Elementen einstellen | DEFAULT = 0)

    EDMA_FMK (RLD, ELERLD, NULL) 	   |  // Reload Element					(Nach erfolgreichem Schreiben von 10.000 Elementen in den
    									  //								 McBSP wird der ELECNT wieder auf 10.000 zurückgesetzt
    									  //								 damit beim nächsten Schreibvorgang wieder 10.000 Elemente
    									  //								 in den McBSP geschrieben werden.
    									  //								 Muss ansonsten nur bei Multiframe-Transfers gesetzt werden, damit ELECNT
    									  //								 für jedes weitere Frame von neuem geladen werden kann.)
    EDMA_FMK (RLD, LINK, 0)               // Reload Link					(01A0 xxxxh ist die Adresse für das jeweilige Reloadset im PaRAM:
    									  //								 0180h (384d) - Buffer_IN_Ping
    									  //								 0198h (408d) - Buffer_IN_Pong
    									  //								 01B0h (432d) - Buffer_OUT_Ping
    									  //								 01C8h (456d) - Buffer_OUT_Pong
    									  //								 Die Verlinkung von PaRAM-Sets findet über die csl-function
    									  //								 EDMA_link() im c-Programm::config_EDMA() statt.)
};



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																															//
//															MCBSP_CONFIGS													//
//																															//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////
// McBSP0_Steuerinterface //
////////////////////////////

static MCBSP_Config configMCBSP1_Steuerinterface =
{
	// McBSP Serial Port Control Register (SPCR) //
	MCBSP_FMKS(SPCR, FREE, NO)			|	// Single Conversion and Free Running.
											// In Single Conversion mode, you have to initiate each conversion. When it is done,
											// the result is placed in the ADC Data register pair and no new conversion is started.
											// In Free Runing mode, you start the conversion only once, and then, the ADC automatically
											// will start the following conversion as soon as the previous one is finished.
											// NO	: 0 Free-running mode is disabled. During emulation halt,
											// 			SOFT bit determines operation of McBSP.
											// YES	: 1 Free-running mode is enabled. During emulation halt, serial clocks continue to run.
	MCBSP_FMKS(SPCR, SOFT, NO)			|	// Soft bit enable mode bit. This bit is used in conjunction with FREE bit to determine
											// state of serial port clock during emulation halt. This bit has no effect if FREE = 1.
											// NO	: 0 Soft mode is disabled. Serial port clock stops immediately during emulation halt,
											//			thus aborting any transmissions.
											// YES	: 1 Soft mode is enabled. During emulation halt, serial port clock stops
											//			after completion of current transmission.
	MCBSP_FMKS(SPCR, FRST, YES)			|	// YES	: 0 Frame-synchronization logic is reset.
											//			Frame-sync signal (FSG) is not generated by the sample-rate generator.
	MCBSP_FMKS(SPCR, GRST, YES)			|	// YES	: 0 Sample-rate generator is reset.
	MCBSP_FMKS(SPCR, XINTM, XRDY)		|	// Transmit Interrupt Mode			(XRDY Bit wird zur Überprüfung benutzt, ob der
											//									 nächste Wert in das AIC23-Register geschrieben werden kann!)
	MCBSP_FMKS(SPCR, XSYNCERR, NO)		|	// empfängerseitig keine Überwachung der Synchronisation
	MCBSP_FMKS(SPCR, XRST, YES)			|	// YES	: 0 Serial port transmitter is disabled and in reset state.
	MCBSP_FMKS(SPCR, DLB, OFF)			|	// Loopback (Kurschluss) nicht aktiv
	MCBSP_FMKS(SPCR, RJUST, RZF)		|	// Receive sign-extension and justification mode bit.
											// RZF	: 0 Right-justify and zero-fill MSBs in DRR.
											// RSE	: 1h Right-justify and sign-extend MSBs in DRR.
											// LZF	: 2h Left-justify and zero-fill LSBs in DRR.
	MCBSP_FMKS(SPCR, CLKSTP, NODELAY)	|	// Clock startet ohne Verzögerung auf fallenden Flanke (siehe auch PCR-Register)
											// 		DISABLE	: Clock stop mode is disabled. Normal clocking for non-SPI mode.
											// In SPI mode with data sampled on rising edge (CLKXP = 0):
											// 		NODELAY	: Clock starts with rising edge without delay.
											// 		DELAY	: Clock starts with rising edge with delay.
											// In SPI mode with data sampled on falling edge (CLKXP = 1):
											// 		NODELAY	: Clock starts with falling edge without delay.
											// 		DELAY	: Clock starts with falling edge with delay.
	MCBSP_FMKS(SPCR, DXENA, OFF)		|	// DX-Enabler wird nicht verwendet
	MCBSP_FMKS(SPCR, RINTM, RRDY)		|	// Receive Interrupt Mode			(Unrelevant)
	MCBSP_FMKS(SPCR, RSYNCERR, NO)		|	// senderseitig keine Überwachung der Synchronisation
	MCBSP_FMKS(SPCR, RRST, YES),			// YES	: 0 The serial port receiver is disabled and in reset state.

	// Empfangs-Control Register (Receive Control Register (RCR)) //
	MCBSP_FMKS(RCR, RPHASE, DEFAULT)	|	// --
	MCBSP_FMKS(RCR, RFRLEN2, DEFAULT)	|	// --
	MCBSP_FMKS(RCR, RWDLEN2, DEFAULT)	|	// --
	MCBSP_FMKS(RCR, RCOMPAND, DEFAULT)	|	// Empfangs-Control Register ist unrelevant, da mit McBSP0
	MCBSP_FMKS(RCR, RFIG, DEFAULT)		|	// nur Konfigurationsdaten an den AIC23 gesendet werden.
	MCBSP_FMKS(RCR, RDATDLY, DEFAULT)	|	// --
	MCBSP_FMKS(RCR, RFRLEN1, DEFAULT)	|	// --
	MCBSP_FMKS(RCR, RWDLEN1, DEFAULT)	|	// --
	MCBSP_FMKS(RCR, RWDREVRS, DEFAULT),		// --

	// Sende-Control Register (Transmit Control Register (TCR)) //
	MCBSP_FMKS(XCR, XPHASE, SINGLE)		|	// Nur eine Phase pro Frame
	MCBSP_FMKS(XCR, XFRLEN2, DEFAULT)	|	// Länge in Phase 2, unrelevant
	MCBSP_FMKS(XCR, XWDLEN2, DEFAULT)	|	// Wortlänge in Phase 2, unrelevant
	MCBSP_FMKS(XCR, XCOMPAND, MSB)		|	// kein Compandierung der Daten (MSB first)
	MCBSP_FMKS(XCR, XFIG, NO)			|	// Transmit frame ignore bit.
											// NO	: 0 Transmit frame-synchronization pulses after the first pulse restarts the transfer.
											// YES	: 1 Transmit frame-synchronization pulses after the first pulse are ignored.
	MCBSP_FMKS(XCR, XDATDLY, 1BIT)		|	// Daten werden nach der FSR-Falling-Edge an den AIC23 gesendet.
	MCBSP_FMKS(XCR, XFRLEN1, OF(0))		|	// Länge der Phase 1	--> 1 Wort
	MCBSP_FMKS(XCR, XWDLEN1, 16BIT)		|	// Wortlänge in Phase 1 --> 16 Bit
	MCBSP_FMKS(XCR, XWDREVRS, DISABLE),		// 32-bit Reversal nicht genutzt

	// Sample Rate Generator Register //
	MCBSP_FMKS(SRGR, GSYNC, FREE)		|	// Sample-rate generator clock synchronization bit is only used when the external clock
											// (CLKS) drives the sample-rate generator clock (CLKSM = 0).
											// The sample-rate generator clock (CLKG) is free running.
	MCBSP_FMKS(SRGR, CLKSP, RISING)		|	// CLKS polarity clock edge select bit is only used when the external clock (CLKS) drives
											// the sample-rate generator clock (CLKSM = 0).
	MCBSP_FMKS(SRGR, CLKSM, INTERNAL)	|	// McBSP sample-rate generator clock mode bit.
											// 0 Sample-rate generator clock is derived from the CLKS pin.	(EXTERNAL)
											// 1 Sample-rate generator clock is derived from CPU/2 clock.	(INTERNAL)
	MCBSP_FMKS(SRGR, FSGM, DXR2XSR)		|	// Transmit frame-sync signal (FSX) is generated on every DXR-to-XSR copy. When
											// FSGM = DXR2XSR, FWID bit and FPER bit are ignored.
	MCBSP_FMKS(SRGR, FPER, DEFAULT)		|	// Unrelevant (Frame period (FPER): The frame period in data bit clocks)
	MCBSP_FMKS(SRGR, FWID, DEFAULT)		|	// Unrelevant (Frame width (FWID): The width of an active frame pulse in data bit clocks)
	MCBSP_FMKS(SRGR, CLKGDV, OF(99)),		// 1/(99+1) --> CPU Clock/2 wird nochmal um den Faktor 100 runtergeteilt und als
											// Ausgangstaktsignal verwendet um den AIC23 zu programmieren.

	// Mehrkanal //
	MCBSP_MCR_DEFAULT,						// Mehrkanal wird nicht verwendet
	MCBSP_RCER_DEFAULT,						// dito
	MCBSP_XCER_DEFAULT,						// dito

	// Pinout Control Register //
	MCBSP_FMKS(PCR, XIOEN, SP)			|	// Pin wird für serielle Schnittstelle verwendet (alternativ GPIO)
											// 0 DX, FSX, and CLKX pins are configured as serial port pins and do not function as
											// general-purpose I/O pins.
											// 1 DX pin is configured as general-purpose output pin(GPIO); FSX and CLKX pins are
											// configured as general-purpose I/O pins. These serial port pins do not perform serial
											// port operations.
	MCBSP_FMKS(PCR, RIOEN, SP)			|	// Pin wird für serielle Schnittstelle verwendet (alternativ GPIO)
											// 0 DR, FSR, CLKR, and CLKS pins are configured as serial port pins and do not
											// function as general-purpose I/O pins.
											// 1 DR and CLKS pins are configured as general-purpose input pins(GPIO); FSR and CLKR
											// pins are configured as general
	MCBSP_FMKS(PCR, FSXM, INTERNAL)		|	// Framesync- Signal wird vom internen Sample-Rate Generator abgeleitet.
											// INTERNAL	: Frame-synchronization signal is determined by FSGM bit in SRGR.
	MCBSP_FMKS(PCR, FSRM, DEFAULT)		|	// Unrelevant, da nur die Senderseite des McBSP0 verwendet wird.
	MCBSP_FMKS(PCR, CLKXM, OUTPUT)		|	// McBSP0 gibt das Taktsignal zum Übertragen der Konfigbits vor (Master).
	MCBSP_FMKS(PCR, CLKRM, DEFAULT)		|	// Unrelevant, da nur die Senderseite des McBSP0 verwendet wird.
	MCBSP_FMKS(PCR, CLKSSTAT, DEFAULT)	|	// Unrelevant, da PINS keine GPIOs
	MCBSP_FMKS(PCR, DXSTAT, DEFAULT)	|	// Unrelevant, da PINS keine GPIOs
	MCBSP_FMKS(PCR, FSXP, ACTIVELOW)	|	// Framesync senderseitig ist "activelow"
											// D.h.: Über den gesamten Zeitraum der Konfigbit-Übertragung ist FSX LOW.
											//		 Das entspricht der Vorgabe des SPI-Interface des AIC23
											//		 solange Konfigbits übertragen werden. Bei erfolgreicher Übertragung des
											//		 letzten Konfigbits geht FSX somit auf HIGH.
											//		 Dadurch wird die erforderliche rising-edge erzeugt um das übertragene 16Bit-Wort
											//		 in das Konfigregister des AIC23 zu übernehmen.
	MCBSP_FMKS(PCR, FSRP, DEFAULT)		|	// Unrelevant, da nur die Senderseite des McBSP0 verwendet wird.
	MCBSP_FMKS(PCR, CLKXP, FALLING)		|	// Transmit clock polarity bit.
											// 0 Transmit data sampled on rising edge of CLKX.
											// 1 Transmit data sampled on falling edge of CLKX.
											// --> Datenbits werden bei fallender Flanke vom McBSP0 gesendet und bei steigender Flanke
											//	   vom AIC23 übernommen.
	MCBSP_FMKS(PCR, CLKRP, DEFAULT)			// Unrelevant, da nur die Senderseite des McBSP0 verwendet wird.
};

//////////////////////////
// McBSP1_Datainterface //
//////////////////////////

static MCBSP_Config configMCBSP1_Datainterface =
{
	// McBSP Serial Port Control Register (SPCR) //
	MCBSP_FMKS(SPCR, FREE, NO)			|	// Single Conversion and Free Running.
											// In Single Conversion mode, you have to initiate each conversion. When it is done,
											// the result is placed in the ADC Data register pair and no new conversion is started.
											// In Free Runing mode, you start the conversion only once, and then, the ADC automatically
											// will start the following conversion as soon as the previous one is finished.
											// NO	: 0 Free-running mode is disabled. During emulation halt,
											// 			SOFT bit determines operation of McBSP.
											// YES	: 1 Free-running mode is enabled. During emulation halt, serial clocks continue to run.
	MCBSP_FMKS(SPCR, SOFT, NO)			|	// Soft bit enable mode bit. This bit is used in conjunction with FREE bit to determine
											// state of serial port clock during emulation halt. This bit has no effect if FREE = 1.
											// NO	: 0 Soft mode is disabled. Serial port clock stops immediately during emulation halt,
											//			thus aborting any transmissions.
											// YES	: 1 Soft mode is enabled. During emulation halt, serial port clock stops
											//			after completion of current transmission.
	MCBSP_FMKS(SPCR, FRST, YES)			|	// YES	: 0 Frame-synchronization logic is reset.
											//			Frame-sync signal (FSG) is not generated by the sample-rate generator.
	MCBSP_FMKS(SPCR, GRST, YES)			|	// YES	: 0 Sample-rate generator is reset --> We don't need the SRG because the Framing and
											// Data Clocks will be provided from external by the AIC23.
	MCBSP_FMKS(SPCR, XINTM, XRDY)		|	// Transmit Interrupt Mode			(Auswählen, wann ein XEVT gesendet werden soll
											//									 --> Wenn von DXR in XSR geschrieben wurde(XRDY)
											//									 Damit wird dem EDMA mitgeteilt, dass nun das nächste zu
											//									 sendende Wort in das DXR geschrieben werden kann.)
	MCBSP_FMKS(SPCR, XSYNCERR, NO)		|	// empfängerseitig keine Überwachung der Synchronisation
	MCBSP_FMKS(SPCR, XRST, YES)			|	// YES	: 0 Serial port transmitter is disabled and in reset state.
	MCBSP_FMKS(SPCR, DLB, OFF)			|	// Loopback (Kurschluss) nicht aktiv
	MCBSP_FMKS(SPCR, RJUST, RZF)		|	// Receive sign-extension and justification mode bit.
											// RZF	: 0 Right-justify and zero-fill MSBs in DRR.
											// RSE	: 1h Right-justify and sign-extend MSBs in DRR.
											// LZF	: 2h Left-justify and zero-fill LSBs in DRR.
	MCBSP_FMKS(SPCR, CLKSTP, DISABLE)	|	// Clock startet ohne Verzögerung auf fallenden Flanke (siehe auch PCR-Register)
											// DISABLE	: 0-1h Clock stop mode is disabled. Normal clocking for non-SPI mode.
	MCBSP_FMKS(SPCR, DXENA, OFF)		|	// DX-Enabler wird nicht verwendet
	MCBSP_FMKS(SPCR, RINTM, RRDY)		|	// Receive Interrupt Mode			(Auswählen, wann ein REVT gesendet werden soll
											//									 --> Wenn von RBR in DRR geschrieben wurde(RRDY)
											//									 Damit wird dem EDMA mitgeteilt, dass ein neues Wort im
											//									 DRR bereit liegt und gelesen werden kann.)
	MCBSP_FMKS(SPCR, RSYNCERR, NO)		|	// senderseitig keine Überwachung der Synchronisation
	MCBSP_FMKS(SPCR, RRST, YES),			// YES	: 0 The serial port receiver is disabled and in reset state.

	// Empfangs-Control Register (Receive Control Register (RCR)) //
	MCBSP_FMKS(RCR, RPHASE, SINGLE)		|	// Nur eine Phase pro Frame
	MCBSP_FMKS(RCR, RFRLEN2, DEFAULT)	|	// Länge in Phase 2, unrelevant
	MCBSP_FMKS(RCR, RWDLEN2, DEFAULT)	|	// Wortlänge in Phase 2, unrelevant
	MCBSP_FMKS(RCR, RCOMPAND, MSB)		|	// kein Compandierung der Daten (MSB first)
	MCBSP_FMKS(RCR, RFIG, NO)			|	// Receive frame ignore bit.
											// NO	: 0 Receive frame-synchronization pulses after the first pulse restarts the transfer.
											// YES	: 1 Receive frame-synchronization pulses after the first pulse are ignored.
	MCBSP_FMKS(RCR, RDATDLY, 0BIT)		|	// Datenbits werden ein Bit nach dem FSR an den McBSP gesendet. (AIC23 in DSP Mode konfiguriert)
	MCBSP_FMKS(RCR, RFRLEN1, OF(0))		|	// Länge der Phase 1	--> 1 Wort
	MCBSP_FMKS(RCR, RWDLEN1, 16BIT)		|	// Wortlänge in Phase 1	--> 16 Bit
	MCBSP_FMKS(RCR, RWDREVRS, DISABLE),		// 32-bit Reversal nicht genutzt

	// Sende-Control Register (Transmit Control Register (TCR)) //
	MCBSP_FMKS(XCR, XPHASE, SINGLE)		|	// Nur eine Phase pro Frame
	MCBSP_FMKS(XCR, XFRLEN2, DEFAULT)	|	// Länge in Phase 2, unrelevant
	MCBSP_FMKS(XCR, XWDLEN2, DEFAULT)	|	// Wortlänge in Phase 2, unrelevant
	MCBSP_FMKS(XCR, XCOMPAND, MSB)		|	// kein Compandierung der Daten (MSB first)
	MCBSP_FMKS(XCR, XFIG, NO)			|	// Transmit frame ignore bit.
											// NO	: 0 Transmit frame-synchronization pulses after the first pulse restarts the transfer.
											// YES	: 1 Transmit frame-synchronization pulses after the first pulse are ignored.
	MCBSP_FMKS(XCR, XDATDLY, 0BIT)		|	// Datenbits werden ein Bit nach dem FSX an den AIC23 gesendet. (AIC23 in DSP Mode konfiguriert)
	MCBSP_FMKS(XCR, XFRLEN1, OF(0))		|	// Länge der Phase 1	--> 1 Wort
	MCBSP_FMKS(XCR, XWDLEN1, 16BIT)		|	// Wortlänge in Phase 1 --> 16 Bit
	MCBSP_FMKS(XCR, XWDREVRS, DISABLE),		// 32-bit Reversal nicht genutzt

	// Sample Rate Generator Register //
	MCBSP_FMKS(SRGR, GSYNC, DEFAULT)	|	// Einstellungen nicht relevant da
	MCBSP_FMKS(SRGR, CLKSP, DEFAULT)	|	// der McBSP1 als Slave läuft
	MCBSP_FMKS(SRGR, CLKSM, DEFAULT)	|	// und den Takt von aussen
	MCBSP_FMKS(SRGR, FSGM, DEFAULT)		|	// vorgegeben bekommt.
	MCBSP_FMKS(SRGR, FPER, DEFAULT)		|	// --
	MCBSP_FMKS(SRGR, FWID, DEFAULT)		|	// --> Bekommt Framesync und Takt vom AIC23 vorgegeben (siehe PRC-Einstellungen).
	MCBSP_FMKS(SRGR, CLKGDV, DEFAULT),		// --

	// Mehrkanal //
	MCBSP_MCR_DEFAULT,						// Mehrkanal wird nicht verwendet
	MCBSP_RCER_DEFAULT,						// dito
	MCBSP_XCER_DEFAULT,						// dito

	// Pinout Control Register //
	MCBSP_FMKS(PCR, XIOEN, SP)			|	// Pin wird für serielle Schnittstelle verwendet (alternativ GPIO)
											// 0 DX, FSX, and CLKX pins are configured as serial port pins and do not function as
											// general-purpose I/O pins.
											// 1 DX pin is configured as general-purpose output pin(GPIO); FSX and CLKX pins are
											// configured as general-purpose I/O pins. These serial port pins do not perform serial
											// port operations.
	MCBSP_FMKS(PCR, RIOEN, SP)			|	// Pin wird für serielle Schnittstelle verwendet (alternativ GPIO)
											// 0 DR, FSR, CLKR, and CLKS pins are configured as serial port pins and do not
											// function as general-purpose I/O pins.
											// 1 DR and CLKS pins are configured as general-purpose input pins(GPIO); FSR and CLKR
											// pins are configured as general
	MCBSP_FMKS(PCR, FSXM, EXTERNAL)		|	// Framesync- Signal für Sender kommt von extern (Slave)
	MCBSP_FMKS(PCR, FSRM, EXTERNAL)		|	// Framesync- Signal für Empfänger kommt von extern (Slave)
	MCBSP_FMKS(PCR, CLKXM, INPUT)		|	// Takt für Sender kommt von extern (Slave)
	MCBSP_FMKS(PCR, CLKRM, INPUT)		|	// Takt für Empfänger kommt von extern (Slave)
	MCBSP_FMKS(PCR, CLKSSTAT, DEFAULT)	|	// unrelevant da PINS keine GPIOs
	MCBSP_FMKS(PCR, DXSTAT, DEFAULT)	|	// unrelevant da PINS keine GPIOs
	MCBSP_FMKS(PCR, FSXP, ACTIVEHIGH)	|	// Framesync senderseitig ist "activehigh"
	MCBSP_FMKS(PCR, FSRP, ACTIVEHIGH)	|	// Framesync empfängerseitig ist "activehigh"
	MCBSP_FMKS(PCR, CLKXP, FALLING)		|	// Transmit clock polarity bit.
											// 0 Transmit data sampled on rising edge of CLKX.
											// 1 Transmit data sampled on falling edge of CLKX.
											// --> Audio-Bit-Sample wird bei fallender Flanke an den AIC23 gesendet,
											//     damit der AIC23 das Bit-Sample bei steigender Flanke übernehmen kann.
											// If CLKXP = 1 and external clocking is selected, the external falling-edge-triggered input clock
											// on CLKX is inverted to a rising-edge-triggered clock before being sent to the transmitter.
	MCBSP_FMKS(PCR, CLKRP, RISING)			// Receive clock polarity bit.
											// 0 Receive data sampled on falling edge of CLKR.
											// 1 Receive data sampled on rising edge of CLKR.
											// --> Audio-Bit-Sample wird bei steigender Flanke vom AIC23 übernommen,
											//	   denn der AIC23 sendet bei vorheriger, fallender Flanke das Bit-Sample.
											//	  (The receive data arriving at the DR pin is sampled on the falling edge of CLKR)
};



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																															//
//															AIC23_CONFIG													//
//																															//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static unsigned short configAIC23_Parameters[10] = {
	0x001F,	// Set-Up	Reg 0	* Left line input channel volume control *
			// LRS		0		Left/right line simultaneous volume/mute update
			//					Simultaneous update:	0 = Disabled	1 = Enabled
			// LIM		0		Left line input mute:	0 = Normal		1 = Muted
			// XX		00		Reserved
			// LIV		11111	Left line input volume control (10111 = 0 dB default)
			//					11111 = +12 dB down to 00000 = –34.5 dB in 1.5-dB step

	0x0097, // Set-Up	Reg 1	* Right line input channel volume control *
			// RLS		0		Right/left line simultaneous volume/mute update
			//					Simultaneous update:	0 = Disabled	1 = Enabled
			// RIM		1		Right line input mute:	0 = Normal		1 = Muted
			// XX		00		Reserved
			// RIV		10111	Right line input volume control (10111 = 0 dB default)
			//					11111 = +12 dB down to 00000 = –34.5 dB in 1.5-dB steps

	0x00F9, // Set-Up	Reg 2	* Left output channel headphone volume control *
			// LRS		0		Left/right headphone channel simultaneous volume/mute update
			//					Simultaneous update:	0 = Disabled	1 = Enabled
			// LZC		1		Left-channel zero-cross detect
			//					Zero-cross detect:		0 = Off			1 = On
			// LHV		1111001	Left Headphone volume control (1111001 = 0 dB default)
			//					1111111 = +6 dB, 79 steps between +6 dB and –73 dB (mute), 0110000 = –73 dB (mute),
			//					any thing below 0110000 does nothing – you are still muted

	0x0030, // Set-Up	Reg 3	* Right output channel headphone volume control *
			// RLS		0		Right/left headphone channel simultaneous volume/mute Update
			//					Simultaneous update:	0 = Disabled	1 = Enabled
			// RZC		0		Right-channel zero-cross detect
			//					Zero-cross detect:		0 = Off			1 = On
			// RHV		0110000	Right headphone volume control (1111001 = 0 dB default)
			//					1111111 = +6 dB, 79 steps between +6 dB and –73 dB (mute), 0110000 = –73 dB (mute),
			//					any thing below 0110000 does nothing – you are still muted

	0x0011, // Set-Up	Reg 4	* Analog audio path control *
			// X		0       Reserved
			// STA		00		Sidetone attenuation	00 = –6 dB		01 = –9 dB		10 = –12 dB		11 = –15 dB
			// STE		0		Sidetone enable			0 = Disabled	1 = Enabled
			// DAC		1		DAC select				0 = DAC off		1 = DAC selected
			// BYP		0		Bypass					0 = Disabled	1 = Enabled
			// INSEL	0		Input select for ADC	0 = Line		1 = Microphone
			// MICM		0		Microphone mute			0 = Normal		1 = Muted
			// MICB		1		Microphone boost		0 = 0 dB		1 = 20 dB

	0x0000, // Set-Up	Reg 5	* Digital audio path control *
			// XXXXX	00000	Reserved
			// DACM		0		DAC soft mute			0 = Disabled	1 = Enabled
			// DEEMP	00		De-emphasis control		00 = Disabled	01 = 32 kHz		10 = 44.1 kHz	11 = 48 kHz
			// ADCHP	0		ADC high-pass filter	0 = Disabled	1 = Enabled

	0x0000, // Set-Up	Reg 6	* Power down control *
			// X		0		Reserved
			// OFF		0		Device power			0 = On			1 = Off
			// CLK		0		Clock					0 = On			1 = Off
			// OSC		0		Oscillator				0 = On			1 = Off
			// OUT		0		Outputs					0 = On			1 = Off
			// DAC		0		DAC						0 = On			1 = Off
			// ADC		0		ADC						0 = On			1 = Off
			// MIC		0		Microphone input		0 = On			1 = Off
			// LINE		0		Line input				0 = On			1 = Off

	0x0041, // Set-Up	Reg 7	* Digital audio interface format *
			// XX		00		Reserved
			// MS		1		Master/slave mode		0 = Slave		1 = Master
			// LRSWAP	0		DAC left/right swap		0 = Disabled	1 = Enabled
			// LRP		0		DSP mode				1 = MSB is available on 2nd BCLK rising edge after LRCIN rising edge
			//											0 = MSB is available on 1st BCLK rising edge after LRCIN rising edge
			// IWL		00		Input bit length		00 = 16 bit		01 = 20 bit		10 = 24 bit		11 = 32 bit
			// FOR		01		Data format				11 = DSP format, frame sync followed by two data words
			//											10 = I2S format, MSB first, left – 1 aligned
			//											01 = MSB first, left aligned
			//											00 = MSB first, right aligned

	0x0001, // Set-Up	Reg 8	* Sample rate control *
			// X		0		Reserved
			// CLKOUT	0		Clock output divider	0 = MCLK		1 = MCLK/2
			// CLKIN	0		Clock input divider		0 = MCLK		1 = MCLK/2
			// SR		0000	sampling rate: ADC 48 kHz, DAC 48 kHz in USB mode
			// BOSR		0		Base oversampling rate
			//					USB mode:				0 = 250 fs		1 = 272 fs
			//					Normal mode:			0 = 256 fs		1 = 384 fs
			// USB/N	1		Clock mode select:		0 = Normal		1 = USB

	0x0001  // Set-Up	Reg 9	* Digital interface activation *
			// XX..X	00000000	Reserved
			// ACT		1		Activate interface		0 = Inactive	1 = Active



			// Set-up	Reg 15	* Reset Register *
			// RES				Write 000000000 to this register triggers reset
};

#endif /*SKELETON_H*/
